import json
import logging
import os
import signal
import sys
from logging.handlers import RotatingFileHandler

from flask import Blueprint, jsonify, request  # 导入 request

# from loguru import logger
# 导入并调用处理函数
from app.modules3.customer import create_customer_from_external_data
from app.modules4.salesman import save_salesman_customer_relation, get_customer_by_salesman, get_salesman_by_customer, \
    save_salesman_customer_relation_md, get_customer_by_salesman_md, get_salesman_by_customer_md, \
    get_customers_by_recommend_md

# 导入供应商蓝图
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'modules1'))
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'modules2'))
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'modules3'))
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'modules4'))
# 导入VendorInquire模块中的供应商查询功能
from app.modules1.disposeData.VendorInquire import get_vendor_type_and_id, get_vendor_data_by_type, \
    get_vendor_summary_by_type, normalize_vendor_data, update_paid_amount
# 导入客户管理模块
from app.modules4.order_stats import get_customer_orders, calculate_performance_stats
# 配置模块级别的日志处理器
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)  # 设置logger的基本级别
logger.propagate = True  # 启用日志传播
# 动态生成日志路径并确保目录存在
log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', 'logs')
os.makedirs(log_dir, exist_ok=True)
log_file_path = os.path.join(log_dir, 'api.log')

handler = RotatingFileHandler(
    log_file_path,
    maxBytes=10000000,
    backupCount=5,
    encoding='utf-8-sig',  # 添加BOM头
    errors='strict'
)
handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
handler.setLevel(logging.INFO)
logger.addHandler(handler)


api_bp = Blueprint('api', __name__)


# 添加信号处理函数
def handle_exit(signum, frame):
    logger.critical(f'程序收到终止信号: {signum}, 即将退出')
    sys.exit(0)

# 注册信号处理
signal.signal(signal.SIGTERM, handle_exit)
signal.signal(signal.SIGINT, handle_exit)

# 添加未捕获异常处理
sys.excepthook = lambda type, value, traceback: \
    logger.critical('未捕获的异常', exc_info=(type, value, traceback))


@api_bp.route('/auto')
def auto():
    logger.debug("auto")
    return jsonify({'messages': 'auto'})


@api_bp.route('/hello')
def hello():
    return jsonify({'message': 'Hello World!'})


# 测试API，不做任何校验，只打印接收到的数据
@api_bp.route('/test_api', methods=['POST'])
def test_api():
    try:
        # 获取原始请求体数据
        raw_data = request.get_data(as_text=True)

        # 只记录原始请求体
        logger.info(f'原始请求体: {repr(raw_data)}')

        # 尝试解析JSON（安全方式）
        json_data = None
        json_error = None
        try:
            import json
            if raw_data and raw_data.strip():
                json_data = json.loads(raw_data)
            else:
                json_error = '请求体为空'
        except json.JSONDecodeError as e:
            json_error = f'JSON格式错误: {str(e)}'
        except Exception as e:
            json_error = f'解析异常: {str(e)}'

        # 简化的响应数据
        response_data = {
            'success': True,
            'message': '数据接收成功',
            'raw_data': raw_data,
            'json_data': json_data,
            'json_error': json_error
        }

        return jsonify(response_data)

    except Exception as e:
        error_msg = f'测试API发生错误: {str(e)}'
        logger.error(error_msg)
        return jsonify({
            'success': False,
            'message': error_msg
        }), 500


# 供应商查询相关接口
@api_bp.route('/vendor/info', methods=['GET'])
def get_vendor_info():
    """
    根据供应商名称获取供应商基本信息（结算类型和ID）
    """
    try:
        vendor_name = request.args.get('vendor_name')
        if not vendor_name:
            return jsonify({
                'success': False,
                'message': '请提供供应商名称参数 vendor_name',
                'data': None
            }), 400

        logger.info(f'查询供应商基本信息: {vendor_name}')

        # 调用VendorInquire模块的函数
        result = get_vendor_type_and_id(vendor_name)

        if result:
            settlement_type, vendor_id = result
            response_data = {
                'success': True,
                'message': '查询成功',
                'data': {
                    'vendor_name': vendor_name,
                    'vendor_id': vendor_id,
                    'settlement_type': settlement_type
                }
            }
            logger.info(f'供应商信息查询成功: {vendor_name} - {settlement_type}')
            return jsonify(response_data), 200
        else:
            logger.warning(f'未找到供应商: {vendor_name}')
            return jsonify({
                'success': False,
                'message': f'未找到供应商: {vendor_name}',
                'data': None
            }), 404

    except Exception as e:
        error_msg = f'查询供应商信息时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


@api_bp.route('/vendor/data', methods=['GET'])
def get_vendor_data():
    """
    根据供应商名称获取对应的详细数据
    月结供应商返回采购明细，实销实结供应商返回销售明细
    """
    try:
        vendor_name = request.args.get('vendor_name')
        if not vendor_name:
            return jsonify({
                'success': False,
                'message': '请提供供应商名称参数 vendor_name',
                'data': []
            }), 400

        logger.info(f'查询供应商详细数据: {vendor_name}')

        # 调用VendorInquire模块的函数
        result = get_vendor_data_by_type(vendor_name)

        response_data = {
            'success': True,
            'message': f'查询成功，共找到 {len(result)} 条数据',
            'data': result,
            'count': len(result)
        }

        logger.info(f'供应商详细数据查询成功: {vendor_name} - {len(result)} 条数据')
        return jsonify(response_data), 200

    except Exception as e:
        error_msg = f'查询供应商详细数据时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': []
        }), 500


@api_bp.route('/vendor/summary', methods=['GET'])
def get_vendor_summary():
    """
    根据供应商名称获取汇总数据
    """
    try:
        vendor_name = request.args.get('vendor_name')
        if not vendor_name:
            return jsonify({
                'success': False,
                'message': '请提供供应商名称参数 vendor_name',
                'data': None
            }), 400

        logger.info(f'查询供应商汇总数据: {vendor_name}')

        # 调用VendorInquire模块的函数
        result = get_vendor_summary_by_type(vendor_name)

        if 'error' in result:
            logger.warning(f'供应商汇总数据查询失败: {result["error"]}')
            return jsonify({
                'success': False,
                'message': result['error'],
                'data': None
            }), 404
        else:
            # 统一字段名称，将不同表的字段映射为相同名称
            normalized_result = normalize_vendor_data(result)

            logger.info(f'供应商汇总数据查询成功: {vendor_name}')
            return jsonify({
                'success': True,
                'message': '查询成功',
                'data': normalized_result
            }), 200

    except Exception as e:
        error_msg = f'查询供应商汇总数据时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@api_bp.route('/update_paid_amount', methods=['POST'])
def api_update_paid_amount():
    """
    更新累计已付金额的API接口
    """
    try:
        # 检查Content-Type
        content_type = request.headers.get('Content-Type', '')
        if 'application/json' not in content_type:
            logger.warning(f'请求Content-Type不正确: {content_type}')
            return jsonify({
                'success': False,
                'message': f'请求Content-Type必须为application/json，当前为: {content_type}',
                'updated_count': 0
            }), 400

        # 获取原始请求数据进行调试
        raw_data = request.get_data(as_text=True)
        logger.info(f'收到原始请求数据: {repr(raw_data)}')

        # 尝试解析JSON
        try:
            request_data = request.get_json(force=True)
        except Exception as json_error:
            logger.error(f'JSON解析失败: {str(json_error)}')
            logger.error(f'原始数据: {repr(raw_data)}')
            return jsonify({
                'success': False,
                'message': f'JSON格式错误: {str(json_error)}',
                'updated_count': 0,
                'raw_data': raw_data[:200]  # 只显示前200个字符
            }), 400

        if not request_data:
            logger.warning('收到空的请求数据')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空',
                'updated_count': 0
            }), 400

        # 处理不同的数据格式
        update_data = None

        # 检查是否为新的嵌套格式（包含vendor_name和details）
        if 'vendor_name' in request_data and 'details' in request_data:
            logger.info('检测到嵌套格式数据')
            update_data = request_data
        # 检查是否为原有的列表格式（包含data字段）
        elif 'data' in request_data:
            logger.info('检测到原有列表格式数据')
            update_data = request_data.get('data', [])
        else:
            logger.warning('请求数据格式不正确，缺少必要字段')
            return jsonify({
                'success': False,
                'message': '请求数据格式不正确，需要包含vendor_name+details或data字段',
                'updated_count': 0
            }), 400

        if not update_data:
            logger.warning('请求数据为空')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空',
                'updated_count': 0
            }), 400

        # 记录接收到的数据信息
        if isinstance(update_data, dict) and 'details' in update_data:
            data_count = len(update_data.get('details', []))
            logger.info(
                f'收到更新累计已付金额请求（嵌套格式），供应商: {update_data.get("vendor_name")}, 明细条数: {data_count}')
        else:
            data_count = len(update_data) if isinstance(update_data, list) else 0
            logger.info(f'收到更新累计已付金额请求（列表格式），数据条数: {data_count}')

        # 调用更新函数
        result = update_paid_amount(update_data)

        # 记录操作结果
        if result['success']:
            logger.info(f'累计已付金额更新成功: {result["message"]}')
            return jsonify(result), 200
        else:
            logger.error(f'累计已付金额更新失败: {result["message"]}')
            return jsonify(result), 500

    except Exception as e:
        error_msg = f'API处理过程中发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'updated_count': 0
        }), 500


@api_bp.route('/customer/orders', methods=['GET'])
def get_customer_order_stats():
    """
    获取客户订单统计数据
    请求参数：
    - customer_code: 客户编号（必填）
    返回数据：
    - orders: 订单列表
    - stats: 统计数据（订单总数、销售总额、商品统计、月度统计等）
    """
    try:
        customer_code = request.args.get('customer_code')
        if not customer_code:
            return jsonify({
                'success': False,
                'message': '请提供客户编号参数 customer_code',
                'data': None
            }), 400

        logger.info(f'查询客户订单统计数据: {customer_code}')

        # 获取客户订单数据
        orders = get_customer_orders(customer_code)
        if not orders:
            logger.warning(f'未找到客户订单数据: {customer_code}')
            return jsonify({
                'success': False,
                'message': f'未找到客户 {customer_code} 的订单数据',
                'data': None
            }), 404

        # 计算统计数据
        stats = calculate_performance_stats(orders)

        response_data = {
            'success': True,
            'message': '查询成功',
            'data': {
                'orders': orders,
                'stats': stats
            }
        }

        logger.info(f'客户订单统计查询成功: {customer_code}, 订单数: {stats["total_orders"]}')
        return jsonify(response_data), 200

    except Exception as e:
        error_msg = f'查询客户订单统计数据时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


@api_bp.route('/customer/create_from_external', methods=['POST'])
def create_customer_from_external():
    """
    根据外部传入的简化数据格式创建客户档案
    接收外部系统的客户数据，自动处理并创建客户档案
    """
    try:
        # 检查Content-Type
        content_type = request.headers.get('Content-Type', '')
        if 'application/json' not in content_type:
            logger.warning(f'请求Content-Type不正确: {content_type}')
            return jsonify({
                'success': False,
                'message': f'请求Content-Type必须为application/json，当前为: {content_type}'
            }), 400

        # 获取原始请求数据进行调试
        raw_data = request.get_data(as_text=True)
        logger.info(f'收到外部客户创建请求，原始数据: {raw_data}')

        # 尝试解析JSON
        try:
            # 先尝试修复常见的JSON格式错误
            fixed_raw_data = raw_data
            # 替换中文引号为英文引号
            fixed_raw_data = fixed_raw_data.replace('"', '"').replace('"', '"')
            # 替换中文冒号为英文冒号
            fixed_raw_data = fixed_raw_data.replace('：', ':')

            # 尝试解析修复后的JSON
            external_data = json.loads(fixed_raw_data)
            logger.info('成功修复并解析JSON数据')
        except json.JSONDecodeError as json_error:
            logger.error(f'JSON解析失败: {str(json_error)}')
            logger.error(f'原始数据: {raw_data}')
            logger.error(f'修复后数据: {fixed_raw_data}')
            return jsonify({
                'success': False,
                'message': f'JSON格式错误: {str(json_error)}'
            }), 400
        except Exception as e:
            logger.error(f'处理JSON数据时发生未知错误: {str(e)}')
            return jsonify({
                'success': False,
                'message': f'处理数据时发生错误: {str(e)}'
            }), 400

        if not external_data:
            logger.warning('收到空的请求数据')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400

        # 记录接收到的数据
        customer_code = external_data.get('customerCode')
        nickname = external_data.get('nickname')
        logger.info(f'开始处理外部客户数据 - 客户编码: {customer_code}, 客户名称: {nickname}')
        # 调用处理函数
        result = create_customer_from_external_data(external_data)

        # 记录操作结果
        if result.get('success', False):
            logger.info(f'外部客户创建成功: {customer_code} - {nickname}')
            return jsonify({
                'message': '客户创建成功',
                'data': f'客户编号：{customer_code}' 
            }), 200
        else:
            logger.error(f'外部客户创建失败: {result.get("message", "未知错误")}')
            return jsonify({
                'success': False,
                'message': f'客户创建失败: {result.get("message", "未知错误")}',
                'data': result
            }), 400

    except Exception as e:
        error_msg = f'外部客户创建API处理过程中发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg
        }), 500


@api_bp.route('/salesman/bind_customer', methods=['POST'])
def bind_salesman_customer():
    """
    保存业务员和客户的绑定关系
    接收业务员名称、客户编码和客户名称，将关系保存到数据库
    """
    try:
        # 检查Content-Type
        content_type = request.headers.get('Content-Type', '')
        if 'application/json' not in content_type:
            logger.warning(f'请求Content-Type不正确: {content_type}')
            return jsonify({
                'success': False,
                'message': f'请求Content-Type必须为application/json，当前为: {content_type}'
            }), 400

        # 获取原始请求数据
        raw_data = request.get_data(as_text=True)
        logger.info(f'收到业务员客户绑定请求，原始数据: {raw_data}')

        # 尝试解析JSON
        try:
            # 尝试解析JSON数据
            bind_data = json.loads(raw_data)
            logger.info('成功解析JSON数据')
        except json.JSONDecodeError as json_error:
            logger.error(f'JSON解析失败: {str(json_error)}')
            logger.error(f'原始数据: {raw_data}')
            return jsonify({
                'success': False,
                'message': f'JSON格式错误: {str(json_error)}'
            }), 400
        except Exception as e:
            logger.error(f'处理JSON数据时发生未知错误: {str(e)}')
            return jsonify({
                'success': False,
                'message': f'处理数据时发生错误: {str(e)}'
            }), 400

        if not bind_data:
            logger.warning('收到空的请求数据')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400

        # 记录接收到的数据
        salesman_name = bind_data.get('salesman_name')
        customer_code = bind_data.get('customer_code')
        customer_name = bind_data.get('customer_name')
        logger.info(
            f'开始处理业务员客户绑定 - 业务员: {salesman_name}, 客户编码: {customer_code}, 客户名称: {customer_name}')

        # 调用处理函数
        result = save_salesman_customer_relation(bind_data)

        # 记录操作结果
        if result.get('success', False):
            logger.info(f'业务员客户绑定成功: {salesman_name} - {customer_code}')
            return jsonify({
                'success': True,
                'message': result.get('message', '业务员客户绑定成功')
            }), 200
        else:
            logger.error(f'业务员客户绑定失败: {result.get("message", "未知错误")}')
            return jsonify({
                'success': False,
                'message': result.get('message', '业务员客户绑定失败')
            }), 400

    except Exception as e:
        error_msg = f'业务员客户绑定API处理过程中发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg
        }), 500


@api_bp.route('/salesman/customers', methods=['GET'])
def get_salesman_customers():
    """
    获取业务员负责的所有客户
    """
    try:
        salesman_name = request.args.get('salesman_name')
        if not salesman_name:
            return jsonify({
                'success': False,
                'message': '请提供业务员名称参数 salesman_name',
                'data': []
            }), 400

        logger.info(f'查询业务员负责的客户: {salesman_name}')

        # 调用处理函数
        customers = get_customer_by_salesman(salesman_name)

        return jsonify({
            'success': True,
            'message': f'查询成功，共找到 {len(customers)} 个客户',
            'data': customers,
            'count': len(customers)
        }), 200

    except Exception as e:
        error_msg = f'查询业务员客户列表时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': []
        }), 500


@api_bp.route('/customer/salesman', methods=['GET'])
def get_customer_salesman():
    """
    获取负责指定客户的业务员
    """
    try:
        customer_code = request.args.get('customer_code')
        if not customer_code:
            return jsonify({
                'success': False,
                'message': '请提供客户编码参数 customer_code',
                'data': None
            }), 400

        logger.info(f'查询客户的负责业务员: {customer_code}')

        # 调用处理函数
        salesman = get_salesman_by_customer(customer_code)

        if salesman:
            return jsonify({
                'success': True,
                'message': '查询成功',
                'data': salesman
            }), 200
        else:
            return jsonify({
                'success': False,
                'message': f'未找到客户 {customer_code} 的负责业务员',
                'data': None
            }), 404

    except Exception as e:
        error_msg = f'查询客户业务员时发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


# 门店专属接口

# 门店新增客户接口，区别只在渠道和客户编号前缀
@api_bp.route('/customer/create_from_external_Md', methods=['POST'])
def create_customer_from_external_Md():
    """
    根据外部传入的简化数据格式创建客户档案
    接收外部系统的客户数据，自动处理并创建客户档案
    """
    try:
        # 检查Content-Type
        content_type = request.headers.get('Content-Type', '')
        if 'application/json' not in content_type:
            logger.warning(f'请求Content-Type不正确: {content_type}')
            return jsonify({
                'success': False,
                'message': f'请求Content-Type必须为application/json，当前为: {content_type}'
            }), 400

        # 获取原始请求数据进行调试
        raw_data = request.get_data(as_text=True)
        logger.info(f'收到外部客户创建请求，原始数据: {raw_data}')

        # 尝试解析JSON
        try:
            # 先尝试修复常见的JSON格式错误
            fixed_raw_data = raw_data
            # 替换中文引号为英文引号
            fixed_raw_data = fixed_raw_data.replace('"', '"').replace('"', '"')
            # 替换中文冒号为英文冒号
            fixed_raw_data = fixed_raw_data.replace('：', ':')

            # 尝试解析修复后的JSON
            external_data = json.loads(fixed_raw_data)
            logger.info('成功修复并解析JSON数据')
        except json.JSONDecodeError as json_error:
            logger.error(f'JSON解析失败: {str(json_error)}')
            logger.error(f'原始数据: {raw_data}')
            logger.error(f'修复后数据: {fixed_raw_data}')
            return jsonify({
                'success': False,
                'message': f'JSON格式错误: {str(json_error)}'
            }), 400
        except Exception as e:
            logger.error(f'处理JSON数据时发生未知错误: {str(e)}')
            return jsonify({
                'success': False,
                'message': f'处理数据时发生错误: {str(e)}'
            }), 400

        if not external_data:
            logger.warning('收到空的请求数据')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400

        # 记录接收到的数据
        customer_code = external_data.get('customerCode')
        nickname = external_data.get('nickname')
        logger.info(f'开始处理外部客户数据(MD) - 客户编码: {customer_code}, 客户名称: {nickname}')
        # 调用处理函数
        from app.modules3.customer_md import create_customer_from_external_data_md
        result = create_customer_from_external_data_md(external_data)

        # 记录操作结果
        if result.get('success', False):
            logger.info(f'客户创建成功: {customer_code} - {nickname}')
            return jsonify({
                'message': '客户创建成功',
                'data': f'客户编号：{customer_code}'
            }), 200
        else:
            logger.error(f'外部客户创建失败: {result.get("message", "未知错误")}')
            return jsonify({
                'success': False,
                'message': f'客户创建失败: {result.get("message", "未知错误")}',
                'data': result
            }), 400

    except Exception as e:
        error_msg = f'外部客户创建API处理过程中发生错误: {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg
        }), 500


@api_bp.route('/salesman/bind_customer_md', methods=['POST'])
def bind_salesman_customer_md():
    """
    保存业务员和客户的绑定关系（包含推荐人信息）
    接收业务员名称、客户编码、客户名称、推荐人名称、推荐人编码，将关系保存到数据库
    """
    try:
        # 检查Content-Type
        content_type = request.headers.get('Content-Type', '')
        if 'application/json' not in content_type:
            logger.warning(f'请求Content-Type不正确: {content_type}')
            return jsonify({
                'success': False,
                'message': f'请求Content-Type必须为application/json，当前为: {content_type}'
            }), 400

        # 获取原始请求数据
        raw_data = request.get_data(as_text=True)
        logger.info(f'收到业务员客户绑定请求(MD)，原始数据: {raw_data}')

        # 尝试解析JSON
        try:
            # 尝试解析JSON数据
            bind_data = json.loads(raw_data)
            logger.info('成功解析JSON数据')
        except json.JSONDecodeError as json_error:
            logger.error(f'JSON解析失败: {str(json_error)}')
            logger.error(f'原始数据: {raw_data}')
            return jsonify({
                'success': False,
                'message': f'JSON格式错误: {str(json_error)}'
            }), 400
        except Exception as e:
            logger.error(f'处理JSON数据时发生未知错误: {str(e)}')
            return jsonify({
                'success': False,
                'message': f'处理数据时发生错误: {str(e)}'
            }), 400

        if not bind_data:
            logger.warning('收到空的请求数据')
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400

        # 记录接收到的数据
        salesman_name = bind_data.get('salesman_name')
        customer_code = bind_data.get('customer_code')
        customer_name = bind_data.get('customer_name')
        recommend_name = bind_data.get('recommend_name')
        recommend_customer_code = bind_data.get('recommend_customer_code')
        logger.info(
            f'开始处理业务员客户绑定(MD) - 业务员: {salesman_name}, 客户编码: {customer_code}, 客户名称: {customer_name}, 推荐人: {recommend_name}, 推荐人编码: {recommend_customer_code}')

        # 调用处理函数
        result = save_salesman_customer_relation_md(bind_data)

        # 记录操作结果
        if result.get('success', False):
            logger.info(f'业务员客户绑定成功(MD): {salesman_name} - {customer_code}')
            return jsonify({
                'success': True,
                'message': result.get('message', '业务员客户绑定成功')
            }), 200
        else:
            logger.error(f'业务员客户绑定失败(MD): {result.get("message", "未知错误")}')
            return jsonify({
                'success': False,
                'message': result.get('message', '业务员客户绑定失败')
            }), 400

    except Exception as e:
        error_msg = f'业务员客户绑定API处理过程中发生错误(MD): {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg
        }), 500


@api_bp.route('/salesman/customers_md', methods=['GET'])
def get_salesman_customers_md():
    """
    获取业务员负责的所有客户（包含推荐人信息）
    """
    try:
        salesman_name = request.args.get('salesman_name')
        if not salesman_name:
            return jsonify({
                'success': False,
                'message': '请提供业务员名称参数 salesman_name',
                'data': []
            }), 400

        logger.info(f'查询业务员负责的客户(MD): {salesman_name}')

        # 调用处理函数
        customers = get_customer_by_salesman_md(salesman_name)

        return jsonify({
            'success': True,
            'message': f'查询成功，共找到 {len(customers)} 个客户',
            'data': customers,
            'count': len(customers)
        }), 200

    except Exception as e:
        error_msg = f'查询业务员客户列表时发生错误(MD): {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': []
        }), 500


@api_bp.route('/customer/salesman_md', methods=['GET'])
def get_customer_salesman_md():
    """
    获取负责指定客户的业务员（包含推荐人信息）
    """
    try:
        customer_code = request.args.get('customer_code')
        if not customer_code:
            return jsonify({
                'success': False,
                'message': '请提供客户编码参数 customer_code',
                'data': None
            }), 400

        logger.info(f'查询客户的负责业务员(MD): {customer_code}')

        # 调用处理函数
        salesman = get_salesman_by_customer_md(customer_code)

        if salesman:
            return jsonify({
                'success': True,
                'message': '查询成功',
                'data': salesman
            }), 200
        else:
            return jsonify({
                'success': False,
                'message': f'未找到客户 {customer_code} 的负责业务员',
                'data': None
            }), 404

    except Exception as e:
        error_msg = f'查询客户业务员时发生错误(MD): {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


@api_bp.route('/recommend/customers_md', methods=['GET'])
def get_recommend_customers_md():
    """
    获取推荐人推荐的所有客户
    """
    try:
        recommend_name = request.args.get('recommend_name')
        if not recommend_name:
            return jsonify({
                'success': False,
                'message': '请提供推荐人名称参数 recommend_name',
                'data': []
            }), 400

        logger.info(f'查询推荐人推荐的客户(MD): {recommend_name}')

        # 调用处理函数
        customers = get_customers_by_recommend_md(recommend_name)

        return jsonify({
            'success': True,
            'message': f'查询成功，共找到 {len(customers)} 个客户',
            'data': customers,
            'count': len(customers)
        }), 200

    except Exception as e:
        error_msg = f'查询推荐人客户列表时发生错误(MD): {str(e)}'
        logger.error(error_msg, exc_info=True)
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': []
        }), 500
